/**
 * GeoJSON坐标转换工具
 * 主要功能：
 * 1. 调整经度坐标，将地图中心点从0度经线移动到160度经线
 * 2. 特殊处理某些国家的坐标
 * 3. 归一化经度到[-170,170]范围
 */

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
  typeof define === 'function' && define.amd ? define(['exports'], factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.GeoJSONConverter = {}));
})(this, (function (exports) { 'use strict';

  /**
   * 转换GeoJSON坐标 - 适用于Three.js的版本
   * @param {Object} geojson - GeoJSON对象
   * @returns {Object} 转换后的GeoJSON对象
   */
  function teadjustGeoJSON(geojson) {
    // 专门转化Three.js
    if (!geojson || !Array.isArray(geojson.features)) return geojson;

    // 特殊国家列表 - 直接+160度经度
    const specialNames = ['Greenland (Den.)', 'ICELAND', 'CAPE VERDE'];

    // 俄罗斯相关名称
    const eluosi = ['Russia', 'Russian Federation'];

    // 美洲国家列表
    const americas = [
      'UNITED STATES',
      'United States of America',
      'CANADA',
      'MEXICO',
      'GUATEMALA',
      'BELIZE',
      'HONDURAS',
      'EL SALVADOR',
      'NICARAGUA',
      'COSTA RICA',
      'Panama',
      'CUBA',
      'JAMAICA',
      'HAITI',
      'DOMINICAN REPUBLIC',
      'BAHAMAS',
      'Barbados',
      'TRINIDAD AND TOBAGO',
      'St. Lucia',
      'SAINT VINCENT AND THE GRENADINES',
      'GRENADA',
      'Dominica',
      'ST.KITTS AND NEVIS',
      'ANTIGUA AND BARBUDA',
      'COLOMBIA',
      'VENEZUELA',
      'GUYANA',
      'Suriname',
      'ECUADOR',
      'PERU',
      'BRAZIL',
      'Bolivia',
      'Paraguay',
      'Uruguay',
      'ARGENTINA',
      'CHILE',
      'Greenland (Den.)',
      'ICELAND',
      'FRENCH GUIANA',
      'IS.MALVINAS(CLAIMED BY ARG.&U.K.) (FALKLAND IS.)',
      'KIRIBATI',
      'WALLIS AND FUTUNA',
      'CAYMAN ISLANDS',
      'PUERTO RICO',
      'Curacao (Neth.)',
      'MARTINIQUE',
      'TURKS AND CAICOS ISLANDS',
      'GUADELOUPE',
      'Aruba',
      'VIRGIN ISLANDS,U.S.',
      'Montserrat',
      'Virgin Islands\bU.K.',
      'Saint Barthelemy(Fr.)',
      'St. Martin(Fr.)',
      'St.Martin(Neth.)',
      'Sint Eustatius(Neth.)',
      'Saba',
      'ANGUILLA',
      'PITCAIRN ISLANDS',
      'FRENCH POLYNESIA',
    ];

    console.log(`开始处理 ${geojson.features.length} 个地理特征...`);

    geojson.features.forEach((feature, index) => {
      if (!feature.geometry || !feature.geometry.coordinates) return;

      const coords = feature.geometry.coordinates;
      const countryName = feature.properties && feature.properties.NAME_ENG ? feature.properties.NAME_ENG : '';

      // 处理Polygon类型
      if (feature.geometry.type === 'Polygon') {
        coords.forEach((ring) => {
          ring.forEach((point) => {
            if (Array.isArray(point) && typeof point[0] === 'number') {
              let lng = point[0];

              if (specialNames.includes(countryName)) {
                // 特殊国家直接 +160
                lng = lng + 160;
              } else {
                // 处理俄罗斯左边一小块
                if (lng < -160 && eluosi.includes(countryName)) {
                  lng = lng + 160 + 40;
                } else {
                  if (lng >= -30 && lng <= 180) {
                    lng = lng - 160;
                  } else {
                    lng = lng + 160;
                  }
                }
              }

              // 归一化到[-170,170]
              if (lng > 180) lng -= 360;
              if (lng < -180) lng += 360;

              // 美洲国家特殊处理
              if (americas.includes(countryName)) {
                if (lng + 40 > 180) {
                  lng = 180;
                  if (point[1] > 80) {
                    point[1] = 80;
                  }
                } else {
                  lng = lng + 40;
                }
              }

              point[0] = lng;
            }
          });
        });
      }
      // 处理MultiPolygon类型
      else if (feature.geometry.type === 'MultiPolygon') {
        coords.forEach((polygon) => {
          polygon.forEach((ring) => {
            ring.forEach((point) => {
              if (Array.isArray(point) && typeof point[0] === 'number') {
                let lng = point[0];
                if (specialNames.includes(countryName)) {
                  lng = lng + 160;
                } else {
                  // 处理俄罗斯左边一小块
                  if (lng < -160 && eluosi.includes(countryName)) {
                    lng = lng + 160 + 40;
                  } else {
                    if (lng >= -30 && lng <= 180) {
                      lng = lng - 160;
                    } else {
                      lng = lng + 160;
                    }
                  }
                }

                if (lng > 180) lng -= 360;
                if (lng < -180) lng += 360;

                // 美洲国家特殊处理
                if (americas.includes(countryName)) {
                  // 处理一下美国在亚洲2个小点点
                  if (countryName === 'UNITED STATES') {
                    if (lng < 20 && lng > 9 && point[1] < 55.5 && point[1] > 51) {
                      // 避免有2个点被移过去美国连接点
                      lng = lng;
                    } else {
                      if (lng + 40 > 180) {
                        // 超过180的点
                        lng = 180;
                      } else {
                        lng = lng + 40;
                      }
                    }
                  } else {
                    if (lng + 40 > 180) {
                      // 超过180的点
                      lng = 180;
                    } else {
                      lng = lng + 40;
                    }
                  }
                }
                point[0] = lng;
              }
            });
          });
        });
      }

      // 每处理100个特征显示进度
      if ((index + 1) % 100 === 0) {
        console.log(`已处理 ${index + 1}/${geojson.features.length} 个特征...`);
      }
    });

    console.log('坐标转换完成！');
    return geojson;
  }

  /**
   * 转换GeoJSON坐标 - 适用于ECharts的版本
   * @param {Object} geojson - GeoJSON对象
   * @returns {Object} 转换后的GeoJSON对象
   */
  function ecadjustGeoJSON(geojson) {
    if (!geojson || !Array.isArray(geojson.features)) return geojson;

    // 深拷贝避免修改原始对象
    const world = JSON.parse(JSON.stringify(geojson));

    // 对世界地图的json文件中的经纬度坐标进行处理
    const processLng = (lng) => {
      if (lng > -30) {
        lng = lng - 180;
      } else {
        lng = lng + 180;
      }
      return lng;
    };
    
    // 格林兰岛表现怪异
    const processLngGe = (lng) => {
      return lng + 180;
    };

    world.features.map((district) => {
      if (district.properties.name === '格陵兰') {
        if (district.geometry.type === 'Polygon') {
          district.geometry.coordinates.map((border) => {
            border.map((coord) => {
              coord[0] = processLngGe(coord[0]);
            });
          });
        } else {
          district.geometry.coordinates.map((border) => {
            border.map((coordinates) => {
              coordinates.map((coord) => {
                coord[0] = processLngGe(coord[0]);
              });
            });
          });
        }
      } else {
        if (district.geometry.type === 'Polygon') {
          district.geometry.coordinates.map((border) => {
            border.map((coord) => {
              coord[0] = processLng(coord[0]);
            });
          });
        } else {
          district.geometry.coordinates.map((border) => {
            border.map((coordinates) => {
              coordinates.map((coord) => {
                coord[0] = processLng(coord[0]);
              });
            });
          });
        }
      }
    });
    
    // 移除南极洲
    world.features = world.features.filter((district) => district.properties.name !== '南极洲');

    return world;
  }

  /**
   * 从文件路径读取并转换GeoJSON
   * 注意：此方法在浏览器环境中不可用，仅适用于Node.js环境
   * @param {string} inputPath - 输入文件路径
   * @param {string} outputPath - 输出文件路径
   * @param {string} type - 转换类型 ('threejs' 或 'echarts')
   */
  function convertGeoJSONFile(inputPath, outputPath, type = 'threejs') {
    // 此函数仅在Node.js环境中可用
    if (typeof window !== 'undefined') {
      throw new Error('File operations are not supported in browser environment');
    }

    // 动态导入Node.js文件系统模块
    const fs = require('fs');
    
    console.log('=== GeoJSON转换工具 ===');
    console.log(`输入文件路径: ${inputPath}`);
    console.log(`输出文件路径: ${outputPath}`);
    console.log('');

    // 检查输入文件是否存在
    if (!fs.existsSync(inputPath)) {
      throw new Error(`输入文件不存在: ${inputPath}`);
    }

    console.log('✓ 输入文件存在');

    // 读取原始文件
    console.log('正在读取文件...');
    const fileContent = fs.readFileSync(inputPath, 'utf8');
    const originalSize = fileContent.length;
    console.log(`✓ 文件读取成功，大小: ${(originalSize / 1024 / 1024).toFixed(2)} MB`);

    // 解析JSON
    console.log('正在解析JSON数据...');
    const geojson = JSON.parse(fileContent);
    console.log(`✓ JSON解析成功，包含 ${geojson.features?.length || 0} 个特征`);

    // 转换坐标
    console.log('开始坐标转换...');
    const adjustedGeoJSON = type === 'echarts' ? ecadjustGeoJSON(geojson) : teadjustGeoJSON(geojson);

    // 保存转换后的文件
    console.log('正在保存转换后的文件...');
    const outputContent = JSON.stringify(adjustedGeoJSON);
    const outputSize = outputContent.length;

    fs.writeFileSync(outputPath, outputContent, 'utf8');
    console.log(`✓ 文件保存成功: ${outputPath}`);

    // 计算压缩率
    const compressionRatio = ((1 - outputSize / originalSize) * 100).toFixed(2);
    const sizeReduction = ((originalSize - outputSize) / 1024 / 1024).toFixed(2);

    console.log('');
    console.log('=== 转换完成 ===');
    console.log(`原始文件大小: ${(originalSize / 1024 / 1024).toFixed(2)} MB`);
    console.log(`输出文件大小: ${(outputSize / 1024 / 1024).toFixed(2)} MB`);
    console.log(`文件大小变化: ${sizeReduction} MB (${compressionRatio}%)`);
    console.log(`输出文件: ${outputPath}`);
  }

  // 检查是否作为主模块运行（命令行直接调用）
  if (typeof require !== 'undefined' && require.main === module) {
    const fs = require('fs');
    const args = process.argv.slice(2);
    
    if (args.length < 2) {
      console.log('用法: node geojson-converter.js <输入文件> <输出文件> [类型]');
      console.log('类型: threejs (默认) 或 echarts');
      process.exit(1);
    }
    
    const inputPath = args[0];
    const outputPath = args[1];
    const type = args[2] || 'threejs';
    
    try {
      convertGeoJSONFile(inputPath, outputPath, type);
    } catch (error) {
      console.error('❌ 转换过程中发生错误:', error.message);
      process.exit(1);
    }
  }

  // 导出函数
  exports.teadjustGeoJSON = teadjustGeoJSON;
  exports.ecadjustGeoJSON = ecadjustGeoJSON;
  exports.convertGeoJSONFile = convertGeoJSONFile;

  Object.defineProperty(exports, '__esModule', { value: true });

}));